home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2010 May / Mac Life Ubuntu.iso / casper / filesystem.squashfs / usr / src / linux-headers-2.6.28-15 / include / scsi / scsi_cmnd.h < prev    next >
Encoding:
C/C++ Source or Header  |  2008-12-24  |  8.0 KB  |  295 lines
  1. #ifndef _SCSI_SCSI_CMND_H
  2. #define _SCSI_SCSI_CMND_H
  3.  
  4. #include <linux/dma-mapping.h>
  5. #include <linux/blkdev.h>
  6. #include <linux/list.h>
  7. #include <linux/types.h>
  8. #include <linux/timer.h>
  9. #include <linux/scatterlist.h>
  10.  
  11. struct Scsi_Host;
  12. struct scsi_device;
  13.  
  14. /*
  15.  * MAX_COMMAND_SIZE is:
  16.  * The longest fixed-length SCSI CDB as per the SCSI standard.
  17.  * fixed-length means: commands that their size can be determined
  18.  * by their opcode and the CDB does not carry a length specifier, (unlike
  19.  * the VARIABLE_LENGTH_CMD(0x7f) command). This is actually not exactly
  20.  * true and the SCSI standard also defines extended commands and
  21.  * vendor specific commands that can be bigger than 16 bytes. The kernel
  22.  * will support these using the same infrastructure used for VARLEN CDB's.
  23.  * So in effect MAX_COMMAND_SIZE means the maximum size command scsi-ml
  24.  * supports without specifying a cmd_len by ULD's
  25.  */
  26. #define MAX_COMMAND_SIZE 16
  27. #if (MAX_COMMAND_SIZE > BLK_MAX_CDB)
  28. # error MAX_COMMAND_SIZE can not be bigger than BLK_MAX_CDB
  29. #endif
  30.  
  31. struct scsi_data_buffer {
  32.     struct sg_table table;
  33.     unsigned length;
  34.     int resid;
  35. };
  36.  
  37. /* embedded in scsi_cmnd */
  38. struct scsi_pointer {
  39.     char *ptr;        /* data pointer */
  40.     int this_residual;    /* left in this buffer */
  41.     struct scatterlist *buffer;    /* which buffer */
  42.     int buffers_residual;    /* how many buffers left */
  43.  
  44.         dma_addr_t dma_handle;
  45.  
  46.     volatile int Status;
  47.     volatile int Message;
  48.     volatile int have_data_in;
  49.     volatile int sent_command;
  50.     volatile int phase;
  51. };
  52.  
  53. struct scsi_cmnd {
  54.     struct scsi_device *device;
  55.     struct list_head list;  /* scsi_cmnd participates in queue lists */
  56.     struct list_head eh_entry; /* entry for the host eh_cmd_q */
  57.     int eh_eflags;        /* Used by error handlr */
  58.  
  59.     /*
  60.      * A SCSI Command is assigned a nonzero serial_number before passed
  61.      * to the driver's queue command function.  The serial_number is
  62.      * cleared when scsi_done is entered indicating that the command
  63.      * has been completed.  It is a bug for LLDDs to use this number
  64.      * for purposes other than printk (and even that is only useful
  65.      * for debugging).
  66.      */
  67.     unsigned long serial_number;
  68.  
  69.     /*
  70.      * This is set to jiffies as it was when the command was first
  71.      * allocated.  It is used to time how long the command has
  72.      * been outstanding
  73.      */
  74.     unsigned long jiffies_at_alloc;
  75.  
  76.     int retries;
  77.     int allowed;
  78.  
  79.     unsigned char prot_op;
  80.     unsigned char prot_type;
  81.  
  82.     unsigned short cmd_len;
  83.     enum dma_data_direction sc_data_direction;
  84.  
  85.     /* These elements define the operation we are about to perform */
  86.     unsigned char *cmnd;
  87.  
  88.  
  89.     /* These elements define the operation we ultimately want to perform */
  90.     struct scsi_data_buffer sdb;
  91.     struct scsi_data_buffer *prot_sdb;
  92.  
  93.     unsigned underflow;    /* Return error if less than
  94.                    this amount is transferred */
  95.  
  96.     unsigned transfersize;    /* How much we are guaranteed to
  97.                    transfer with each SCSI transfer
  98.                    (ie, between disconnect / 
  99.                    reconnects.   Probably == sector
  100.                    size */
  101.  
  102.     struct request *request;    /* The command we are
  103.                           working on */
  104.  
  105. #define SCSI_SENSE_BUFFERSIZE     96
  106.     unsigned char *sense_buffer;
  107.                 /* obtained by REQUEST SENSE when
  108.                  * CHECK CONDITION is received on original
  109.                  * command (auto-sense) */
  110.  
  111.     /* Low-level done function - can be used by low-level driver to point
  112.      *        to completion function.  Not used by mid/upper level code. */
  113.     void (*scsi_done) (struct scsi_cmnd *);
  114.  
  115.     /*
  116.      * The following fields can be written to by the host specific code. 
  117.      * Everything else should be left alone. 
  118.      */
  119.     struct scsi_pointer SCp;    /* Scratchpad used by some host adapters */
  120.  
  121.     unsigned char *host_scribble;    /* The host adapter is allowed to
  122.                      * call scsi_malloc and get some memory
  123.                      * and hang it here.  The host adapter
  124.                      * is also expected to call scsi_free
  125.                      * to release this memory.  (The memory
  126.                      * obtained by scsi_malloc is guaranteed
  127.                      * to be at an address < 16Mb). */
  128.  
  129.     int result;        /* Status code from lower level driver */
  130.  
  131.     unsigned char tag;    /* SCSI-II queued command tag */
  132. };
  133.  
  134. extern struct scsi_cmnd *scsi_get_command(struct scsi_device *, gfp_t);
  135. extern struct scsi_cmnd *__scsi_get_command(struct Scsi_Host *, gfp_t);
  136. extern void scsi_put_command(struct scsi_cmnd *);
  137. extern void __scsi_put_command(struct Scsi_Host *, struct scsi_cmnd *,
  138.                    struct device *);
  139. extern void scsi_finish_command(struct scsi_cmnd *cmd);
  140.  
  141. extern void *scsi_kmap_atomic_sg(struct scatterlist *sg, int sg_count,
  142.                  size_t *offset, size_t *len);
  143. extern void scsi_kunmap_atomic_sg(void *virt);
  144.  
  145. extern int scsi_init_io(struct scsi_cmnd *cmd, gfp_t gfp_mask);
  146. extern void scsi_release_buffers(struct scsi_cmnd *cmd);
  147.  
  148. extern int scsi_dma_map(struct scsi_cmnd *cmd);
  149. extern void scsi_dma_unmap(struct scsi_cmnd *cmd);
  150.  
  151. struct scsi_cmnd *scsi_allocate_command(gfp_t gfp_mask);
  152. void scsi_free_command(gfp_t gfp_mask, struct scsi_cmnd *cmd);
  153.  
  154. static inline unsigned scsi_sg_count(struct scsi_cmnd *cmd)
  155. {
  156.     return cmd->sdb.table.nents;
  157. }
  158.  
  159. static inline struct scatterlist *scsi_sglist(struct scsi_cmnd *cmd)
  160. {
  161.     return cmd->sdb.table.sgl;
  162. }
  163.  
  164. static inline unsigned scsi_bufflen(struct scsi_cmnd *cmd)
  165. {
  166.     return cmd->sdb.length;
  167. }
  168.  
  169. static inline void scsi_set_resid(struct scsi_cmnd *cmd, int resid)
  170. {
  171.     cmd->sdb.resid = resid;
  172. }
  173.  
  174. static inline int scsi_get_resid(struct scsi_cmnd *cmd)
  175. {
  176.     return cmd->sdb.resid;
  177. }
  178.  
  179. #define scsi_for_each_sg(cmd, sg, nseg, __i)            \
  180.     for_each_sg(scsi_sglist(cmd), sg, nseg, __i)
  181.  
  182. static inline int scsi_bidi_cmnd(struct scsi_cmnd *cmd)
  183. {
  184.     return blk_bidi_rq(cmd->request) &&
  185.         (cmd->request->next_rq->special != NULL);
  186. }
  187.  
  188. static inline struct scsi_data_buffer *scsi_in(struct scsi_cmnd *cmd)
  189. {
  190.     return scsi_bidi_cmnd(cmd) ?
  191.         cmd->request->next_rq->special : &cmd->sdb;
  192. }
  193.  
  194. static inline struct scsi_data_buffer *scsi_out(struct scsi_cmnd *cmd)
  195. {
  196.     return &cmd->sdb;
  197. }
  198.  
  199. static inline int scsi_sg_copy_from_buffer(struct scsi_cmnd *cmd,
  200.                        void *buf, int buflen)
  201. {
  202.     return sg_copy_from_buffer(scsi_sglist(cmd), scsi_sg_count(cmd),
  203.                    buf, buflen);
  204. }
  205.  
  206. static inline int scsi_sg_copy_to_buffer(struct scsi_cmnd *cmd,
  207.                      void *buf, int buflen)
  208. {
  209.     return sg_copy_to_buffer(scsi_sglist(cmd), scsi_sg_count(cmd),
  210.                  buf, buflen);
  211. }
  212.  
  213. /*
  214.  * The operations below are hints that tell the controller driver how
  215.  * to handle I/Os with DIF or similar types of protection information.
  216.  */
  217. enum scsi_prot_operations {
  218.     /* Normal I/O */
  219.     SCSI_PROT_NORMAL = 0,
  220.  
  221.     /* OS-HBA: Protected, HBA-Target: Unprotected */
  222.     SCSI_PROT_READ_INSERT,
  223.     SCSI_PROT_WRITE_STRIP,
  224.  
  225.     /* OS-HBA: Unprotected, HBA-Target: Protected */
  226.     SCSI_PROT_READ_STRIP,
  227.     SCSI_PROT_WRITE_INSERT,
  228.  
  229.     /* OS-HBA: Protected, HBA-Target: Protected */
  230.     SCSI_PROT_READ_PASS,
  231.     SCSI_PROT_WRITE_PASS,
  232.  
  233.     /* OS-HBA: Protected, HBA-Target: Protected, checksum conversion */
  234.     SCSI_PROT_READ_CONVERT,
  235.     SCSI_PROT_WRITE_CONVERT,
  236. };
  237.  
  238. static inline void scsi_set_prot_op(struct scsi_cmnd *scmd, unsigned char op)
  239. {
  240.     scmd->prot_op = op;
  241. }
  242.  
  243. static inline unsigned char scsi_get_prot_op(struct scsi_cmnd *scmd)
  244. {
  245.     return scmd->prot_op;
  246. }
  247.  
  248. /*
  249.  * The controller usually does not know anything about the target it
  250.  * is communicating with.  However, when DIX is enabled the controller
  251.  * must be know target type so it can verify the protection
  252.  * information passed along with the I/O.
  253.  */
  254. enum scsi_prot_target_type {
  255.     SCSI_PROT_DIF_TYPE0 = 0,
  256.     SCSI_PROT_DIF_TYPE1,
  257.     SCSI_PROT_DIF_TYPE2,
  258.     SCSI_PROT_DIF_TYPE3,
  259. };
  260.  
  261. static inline void scsi_set_prot_type(struct scsi_cmnd *scmd, unsigned char type)
  262. {
  263.     scmd->prot_type = type;
  264. }
  265.  
  266. static inline unsigned char scsi_get_prot_type(struct scsi_cmnd *scmd)
  267. {
  268.     return scmd->prot_type;
  269. }
  270.  
  271. static inline sector_t scsi_get_lba(struct scsi_cmnd *scmd)
  272. {
  273.     return scmd->request->sector;
  274. }
  275.  
  276. static inline unsigned scsi_prot_sg_count(struct scsi_cmnd *cmd)
  277. {
  278.     return cmd->prot_sdb ? cmd->prot_sdb->table.nents : 0;
  279. }
  280.  
  281. static inline struct scatterlist *scsi_prot_sglist(struct scsi_cmnd *cmd)
  282. {
  283.     return cmd->prot_sdb ? cmd->prot_sdb->table.sgl : NULL;
  284. }
  285.  
  286. static inline struct scsi_data_buffer *scsi_prot(struct scsi_cmnd *cmd)
  287. {
  288.     return cmd->prot_sdb;
  289. }
  290.  
  291. #define scsi_for_each_prot_sg(cmd, sg, nseg, __i)        \
  292.     for_each_sg(scsi_prot_sglist(cmd), sg, nseg, __i)
  293.  
  294. #endif /* _SCSI_SCSI_CMND_H */
  295.